diff --git a/user_guide/helpers/cookie_helper.html b/user_guide/helpers/cookie_helper.html
index 01d8e78..93959ca 100644
--- a/user_guide/helpers/cookie_helper.html
+++ b/user_guide/helpers/cookie_helper.html
@@ -70,7 +70,7 @@
 
 <h2>set_cookie()</h2>
 
-<p>Sets a cookie containing the values you specify.  There are two ways to pass information this function so that a cookie can be set:
+<p>Sets a cookie containing the values you specify.  There are two ways to pass information to this function so that a cookie can be set:
 Array Method, and Discrete Parameters:</p>
 
 <h4>Array Method</h4>
diff --git a/user_guide/helpers/email_helper.html b/user_guide/helpers/email_helper.html
index 74923a5..7acee1d 100644
--- a/user_guide/helpers/email_helper.html
+++ b/user_guide/helpers/email_helper.html
@@ -72,7 +72,7 @@
 
 <p>Checks if an email is a correctly formatted email. Note that is doesn't actually prove the email will recieve mail, simply that it is a validly formed address.</p>
 <p>It returns TRUE/FALSE</p>
-<code> $this-&gt;load-&gt;helper(email);<br />
+<code> $this-&gt;load-&gt;helper('email');<br />
 <br />
 if (valid_email('email@somesite.com'))<br />
 {<br />
diff --git a/user_guide/helpers/string_helper.html b/user_guide/helpers/string_helper.html
index c8e80bb..489c6b3 100644
--- a/user_guide/helpers/string_helper.html
+++ b/user_guide/helpers/string_helper.html
@@ -136,12 +136,12 @@
 <p>The function accepts the following parameters:
 <code>reduce_multiples(string: text to search in, string: character to reduce, boolean: whether to remove the character from the front and end of the string)</code>
 
-The first parameter contrains the string in which you want to reduce the multiplies. The second parameter contains the character you want to have reduced.
-The third parameter is False by default. If it it's to true it will remove occurences of the character at the beginning and the end of the string. Example:
+The first parameter contains the string in which you want to reduce the multiplies. The second parameter contains the character you want to have reduced.
+The third parameter is FALSE by default; if set to TRUE it will remove occurences of the character at the beginning and the end of the string. Example:
 
 <code>
 $string=",Fred, Bill,, Joe, Jimmy,";<br />
-$string=reduce_multiples($string,",",true); //results in "Fred, Bill, Joe, Jimmy"
+$string=reduce_multiples($string, ", ", TRUE); //results in "Fred, Bill, Joe, Jimmy"
 </code>
 </p> 
 
